home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / tools / shell-tools / reboot 2 / reboot.c < prev    next >
C/C++ Source or Header  |  1996-01-05  |  14KB  |  649 lines

  1. ; /*
  2. CatComp Reboot.cd CFILE Reboot_strings.h NOARRAY NOBLOCK NOCODE
  3. CatComp Reboot.cd CTFILE Reboot_blank.ct
  4. CatComp Reboot.cd Reboot_deutsch.ct CATALOG Catalogs/Deutsch/Reboot.catalog
  5.  
  6. ; DICE
  7. dcc Reboot.c -r -mS -mi -proto -v -oReboot
  8.  
  9. ; SAS
  10. ; SC RESOPT PARM=REGISTERS UCHAR CONSTLIB STREQ ANSI NOSTKCHK NOICONS OPT OPTPEEP Reboot.c
  11. ; Slink LIB:c.o Reboot.o TO Reboot LIB LIB:sc.lib SC SD
  12.  
  13. Quit
  14. */
  15.  
  16. /*
  17. **
  18. **  $VER: Reboot.c 1.3 (6.1.96)
  19. **  Reboot 1.0
  20. **
  21. **  main file
  22. **
  23. **  (C) Copyright 1994-96 by Roland 'Gizzy' Mainz
  24. **          All Rights Reserved
  25. **
  26. */
  27.  
  28. /* We did not want any names before V36 */
  29. #define INTUI_V36_NAMES_ONLY 1
  30.  
  31. /* amiga includes */
  32. #include <exec/types.h>
  33. #include <utility/utility.h>
  34. #include <dos/dos.h>
  35. #include <intuition/intuition.h>
  36. #include <workbench/startup.h>
  37. #include <workbench/icon.h>
  38. #include <libraries/locale.h>
  39.  
  40. /* amiga prototypes */
  41. #include <clib/exec_protos.h>
  42. #include <clib/utility_protos.h>
  43. #include <clib/dos_protos.h>
  44. #include <clib/intuition_protos.h>
  45. #include <clib/icon_protos.h>
  46. #include <clib/locale_protos.h>
  47.  
  48. /* DICE inline stuff */
  49. #ifdef __DICE_INLINE
  50. #define UtilityBase_DECLARED 1
  51. #define IntuitionBase_DECLARED 1
  52. #define IconBase_DECLARED 1
  53. #define LocaleBase_DECLARED 1
  54.  
  55. #include <proto/exec_protos.h>
  56. #include <proto/utility_protos.h>
  57. #include <proto/dos_protos.h>
  58. #include <proto/intuition_protos.h>
  59. #include <proto/icon_protos.h>
  60. #include <proto/locale_protos.h>
  61. #endif /* __DICE_INLINE */
  62.  
  63. /* ansi includes */
  64. #include <string.h>
  65.  
  66. /* version string */
  67. #include "Reboot_rev.h"
  68.  
  69. /* locale */
  70. #define CATCOMP_NUMBERS
  71. #define CATCOMP_STRINGS
  72. #include "Reboot_strings.h"
  73.  
  74. /* misc defines */
  75. #define NAME "Reboot"
  76.  
  77. /* prototypes */
  78.                 void                  chkabort( void );
  79.  
  80. #ifdef _DCC
  81.                 long                  wbmain( struct WBStartup * );
  82. #endif /* _DCC */
  83.  
  84.                 long                  main( long, STRPTR * );
  85.         static  void                  DefaultSettings( void );
  86.         static  void                  FreeInitProjectResult( void );
  87.         static  void                  ReadENVPrefs( void );
  88.  
  89.         static  void                  ClearRDA( void );
  90.         static  void                  ScanRDA( void );
  91.         static  void                  ScanToolTypes( STRPTR * );
  92.  
  93.         static  void                  RunTool( void );
  94.         static  BOOL                  OpenLibStuff( void );
  95.         static  void                  CloseLibStuff( void );
  96.         static  BOOL                  CreateBasicResources( void );
  97.         static  void                  DeleteBasicResources( void );
  98.                 void                  AttemptOpenLibrary( struct Library **, STRPTR, STRPTR, ULONG );
  99.         static  void                  RunTool( void );
  100.         static  void                  MyReboot( void );
  101.                 STRPTR                SafeGetCatalogStr( struct Catalog *, LONG, STRPTR );
  102.  
  103.  
  104.  
  105. /* version_string */
  106. STRPTR versionstring = VERSTAG;
  107.  
  108. long main_retval,
  109.      main_retval2;
  110.  
  111. static struct RDArgs  *startuprda;
  112.  
  113. /* shared libraries */
  114. struct Library *UtilityBase,
  115.                *IntuitionBase,
  116.                *IconBase,
  117.                *LocaleBase;
  118.  
  119. /* locale support */
  120. struct Catalog *ct;
  121.  
  122. /* templates for ReadArgs() */
  123. #define STARTUP_TEMPLATE "REBOOTDELAY/K/N,QUIET=NOREQ/S,OFF/S"
  124. #define ENV_TEMPLATE     STARTUP_TEMPLATE
  125.  
  126.  
  127. static
  128. struct
  129. {
  130.     long *rebootdelay;
  131.     long *noreq;
  132.     long *off;
  133. } result;
  134.  
  135. static
  136. struct
  137. {
  138.     ULONG rebootdelay;
  139.     BOOL  noreq;
  140.     BOOL  off;
  141. } project;
  142.  
  143.  
  144. /* disable CTRL_C break support (DICE CTRL_C abort function) */
  145. void chkabort( void )
  146. {
  147. }
  148.  
  149.  
  150. /* DICE workbench entry */
  151. #ifdef _DCC
  152. long wbmain( struct WBStartup *wbstartup )
  153. {
  154.     /* Call main like SAS-C */
  155.     return( main( 0L, (STRPTR *)wbstartup ) );
  156. }
  157. #endif /* _DCC */
  158.  
  159.  
  160. long main( long ac, STRPTR *av )
  161. {
  162.     LONG               numArgs,
  163.                        x;
  164.     struct WBStartup  *wbstartup;
  165.     struct WBArg      *wbarg;
  166.     struct DiskObject *tooldobj,
  167.                       *projectdobj;
  168.     BPTR               oldToolLock,
  169.                        oldProjectLock;
  170.  
  171.     x = main_retval2 = 0L;
  172.     main_retval = RETURN_OK;
  173.  
  174.     if( CreateBasicResources() )
  175.     {
  176.       DefaultSettings();
  177.  
  178. /* Workbench */
  179.       if( ac == 0L )
  180.       {
  181.         wbstartup = (struct WBStartup *)av;
  182.  
  183.         numArgs = wbstartup -> sm_NumArgs;
  184.         wbarg   = wbstartup -> sm_ArgList;
  185.  
  186.         if( *(wbarg[ 0 ] . wa_Name) )
  187.         {
  188.           if( wbarg[ 0 ] . wa_Lock )
  189.           {
  190.             oldToolLock = CurrentDir( (wbarg[ 0 ] . wa_Lock) );
  191.           }
  192.  
  193.           if( tooldobj = GetDiskObjectNew( (wbarg[ 0 ] . wa_Name) ) )
  194.           {
  195.             /* two possible cases when started from workbench ... */
  196.             if( numArgs < 2L )
  197.             {
  198.               /* ... first case, only our tool icon is given, create one project here */
  199.  
  200.               ScanToolTypes( (STRPTR *)(tooldobj -> do_ToolTypes) );
  201.  
  202.               RunTool();
  203.  
  204.               FreeInitProjectResult();
  205.             }
  206.             else
  207.             {
  208.               /* ... second case, a couple of project icons are given, multiple projects will start from here */
  209.               for( x = 1L ; x < numArgs ; x++ )
  210.               {
  211.                 if( wbarg[ x ] . wa_Lock )
  212.                 {
  213.                   oldProjectLock = CurrentDir( (wbarg[ x ] . wa_Lock) );
  214.                 }
  215.  
  216.                 if( *(wbarg[ x ] . wa_Name) )
  217.                 {
  218.                   if( projectdobj = GetDiskObject( (wbarg[ x ] . wa_Name) ) )
  219.                   {
  220.                     ScanToolTypes( (STRPTR *)(tooldobj -> do_ToolTypes) );
  221.                     ScanToolTypes( (STRPTR *)(projectdobj -> do_ToolTypes) );
  222.  
  223.                     RunTool();
  224.  
  225.                     FreeInitProjectResult();
  226.                     DefaultSettings();
  227.  
  228.                     FreeDiskObject( projectdobj );
  229.                   }
  230.                 }
  231.  
  232.                 if( wbarg[ x ] . wa_Lock )
  233.                 {
  234.                   CurrentDir( oldProjectLock );
  235.                 }
  236.               }
  237.             }
  238.  
  239.             FreeDiskObject( tooldobj );
  240.           }
  241.  
  242.           if( wbarg[ 0 ] . wa_Lock )
  243.           {
  244.             CurrentDir( oldToolLock );
  245.           }
  246.         }
  247.       }
  248.       else
  249.       {
  250. /* CLI/Shell */
  251.         if( startuprda = ReadArgs( STARTUP_TEMPLATE, (LONG *)(&result), NULL ) )
  252.         {
  253.           /* did we get a CTRL_C signal ? */
  254.           if( !CheckSignal( SIGBREAKF_CTRL_C ) )
  255.           {
  256.             ScanRDA();
  257.  
  258.             RunTool();
  259.  
  260.             FreeInitProjectResult();
  261.           }
  262.           else
  263.           {
  264.             main_retval2 = ERROR_BREAK;
  265.             main_retval  = RETURN_WARN;
  266.           }
  267.  
  268.           FreeArgs( startuprda );
  269.         }
  270.         else
  271.         {
  272.           main_retval2 = IoErr();
  273.           main_retval  = RETURN_ERROR;
  274.         }
  275.  
  276.         PrintFault( main_retval2, NAME );
  277.       }
  278.  
  279.       DeleteBasicResources();
  280.     }
  281.  
  282.     SetIoErr( main_retval2 );
  283.  
  284.     return( main_retval );
  285. }
  286.  
  287.  
  288. void DefaultSettings( void )
  289. {
  290.     ClearRDA();
  291.  
  292.     memset( (&project), 0, sizeof(project) );
  293.  
  294.     project . rebootdelay = 2UL;
  295.  
  296.     ReadENVPrefs();
  297. }
  298.  
  299.  
  300. static
  301. void ReadENVPrefs( void )
  302. {
  303.     TEXT  varbuff[ 258 ];
  304.     ULONG varlen;
  305.  
  306.     struct RDArgs envvarrda =
  307.     {
  308.       varbuff,
  309.       256L,
  310.       0L,
  311.       0L,
  312.       NULL,
  313.       0L,
  314.       NULL,
  315.       RDAF_NOPROMPT
  316.     };
  317.  
  318.     if( varlen = GetVar( NAME, varbuff, 256L, 0UL ) )
  319.     {
  320.       varbuff[ varlen ]       = '\n';
  321.       varbuff[ (varlen + 1) ] = '\0';
  322.  
  323.       if( ReadArgs( ENV_TEMPLATE, (LONG *)(&result), (&envvarrda) ) )
  324.       {
  325.         ScanRDA();
  326.  
  327.         FreeArgs( (&envvarrda) );
  328.       }
  329.     }
  330. }
  331.  
  332.  
  333. void ClearRDA( void )
  334. {
  335.     memset( (&result), 0, sizeof(result) );
  336. }
  337.  
  338.  
  339. void ScanRDA( void )
  340. {
  341.     if( result . rebootdelay )
  342.     {
  343.       project . rebootdelay = (ULONG)(*(result . rebootdelay));
  344.     }
  345.  
  346.     if( result . noreq )
  347.     {
  348.       project . noreq = TRUE;
  349.     }
  350.  
  351.     if( result . off )
  352.     {
  353.       project . off = TRUE;
  354.     }
  355.  
  356.     ClearRDA();
  357. }
  358.  
  359.  
  360. void ScanToolTypes( STRPTR *tt )
  361. {
  362.     STRPTR s;
  363.  
  364.     if( s = FindToolType( tt, "REBOOTDELAY" ) )
  365.       (void)StrToLong( s, (LONG *)(&(project . rebootdelay)) ); /* note: result ignored */
  366.  
  367.     if( s = FindToolType( tt, "NOREQ" ) )
  368.       result . noreq = (long *)s;
  369.  
  370.     if( s = FindToolType( tt, "QUIET" ) )
  371.       result . noreq = (long *)s;
  372.  
  373.     if( s = FindToolType( tt, "OFF" ) )
  374.       result . off = (long *)s;
  375.  
  376.     ScanRDA();
  377. }
  378.  
  379. static
  380. void FreeInitProjectResult( void )
  381. {
  382.     /* NOP */
  383. }
  384.  
  385.  
  386. BOOL CreateBasicResources( void )
  387. {
  388.     return( OpenLibStuff() );
  389. }
  390.  
  391.  
  392. void DeleteBasicResources( void )
  393. {
  394.     CloseLibStuff();
  395. }
  396.  
  397.  
  398. BOOL OpenLibStuff( void )
  399. {
  400.     UtilityBase = IconBase = LocaleBase = NULL;
  401.  
  402.     if( IntuitionBase = OpenLibrary( "intuition.library", 37UL ) )
  403.     {
  404.       AttemptOpenLibrary( (&UtilityBase),  NAME, UTILITYNAME,      37UL );
  405.       AttemptOpenLibrary( (&IconBase),     NAME, ICONNAME,         37UL );
  406.       AttemptOpenLibrary( (&LocaleBase),   NAME, "locale.library", 38UL );
  407.  
  408.       if( LocaleBase )
  409.       {
  410.         ct = OpenCatalogA( NULL, NAME ".catalog", NULL );
  411.       }
  412.  
  413.       if( IconBase )
  414.       {
  415.         return( TRUE );
  416.       }
  417.     }
  418.  
  419.     CloseLibStuff();
  420.  
  421.     return( FALSE );
  422. }
  423.  
  424.  
  425. void CloseLibStuff( void )
  426. {
  427.     if( LocaleBase )
  428.     {
  429.       CloseCatalog( ct );
  430.  
  431.       CloseLibrary( LocaleBase );
  432.     }
  433.  
  434.     CloseLibrary( IconBase );
  435.     CloseLibrary( UtilityBase );
  436.     CloseLibrary( IntuitionBase );
  437. }
  438.  
  439.  
  440. void AttemptOpenLibrary( struct Library **library, STRPTR title, STRPTR libname, ULONG libversion )
  441. {
  442.     struct EasyStruct LibNotFoundES =
  443.     {
  444.       sizeof(struct EasyStruct),
  445.       0UL,
  446.       title,
  447.       SafeGetCatalogStr( ct, MSG_LIB_NOT_FOUND_REQTEXT, MSG_LIB_NOT_FOUND_REQTEXT_STR ),
  448.       SafeGetCatalogStr( ct, MSG_LIB_NOT_FOUND_REQGAD,  MSG_LIB_NOT_FOUND_REQGAD_STR )
  449.     };
  450.  
  451.     struct EasyStruct LibWrongVersionES =
  452.     {
  453.       sizeof(struct EasyStruct),
  454.       0UL,
  455.       title,
  456.       SafeGetCatalogStr( ct, MSG_LIB_WRONG_VERSION_REQTEXT, MSG_LIB_WRONG_VERSION_REQTEXT_STR ),
  457.       SafeGetCatalogStr( ct, MSG_LIB_WRONG_VERSION_REQGAD,  MSG_LIB_WRONG_VERSION_REQGAD_STR )
  458.     };
  459.  
  460.     if( (*library) == NULL )
  461.     {
  462.       for( ;; )
  463.       {
  464.         /* attemp to open shared library */
  465.         (*library) = OpenLibrary( libname, 0UL );
  466.  
  467.         if( *library )
  468.         {         
  469.           if( ((*library) -> lib_Version) < libversion )
  470.           {
  471.             EasyRequest( NULL, (&LibWrongVersionES), NULL, libname, libversion );
  472.  
  473.             CloseLibrary( (*library) );
  474.             (*library) = NULL;
  475.           }
  476.  
  477.           break;
  478.         }
  479.  
  480.         /* prompt the user */
  481.         if( EasyRequest( NULL, (&LibNotFoundES), NULL, libname ) == 0L )
  482.         {
  483.           /* user canceled */
  484.           break;
  485.         }
  486.       }
  487.     }
  488. }
  489.  
  490.  
  491. void RunTool( void )
  492. {
  493.     struct EasyStruct RebootES =
  494.     {
  495.       sizeof(struct EasyStruct),
  496.       0UL,
  497.       NAME,
  498.       SafeGetCatalogStr( ct, MSG_REBOOT_REQTEXT, MSG_REBOOT_REQTEXT_STR ),
  499.       SafeGetCatalogStr( ct, MSG_REBOOT_REQGAD,  MSG_REBOOT_REQGAD_STR )
  500.     };
  501.  
  502.     if( project . noreq )
  503.     {
  504.       MyReboot();
  505.     }
  506.     else
  507.     {
  508.       if( EasyRequest( NULL, (&RebootES), NULL ) == 1L )
  509.       {
  510.         /* user wants to reboot */
  511.         MyReboot();
  512.       }
  513.       else
  514.       {
  515.         main_retval2 = ERROR_BREAK;
  516.         main_retval  = RETURN_WARN;
  517.       }
  518.     }
  519. }
  520.  
  521.  
  522. void MyReboot( void )
  523. {
  524.     struct Window *abortreqwindow;
  525.     ULONG          delay,
  526.                    x;
  527.     BOOL           abort;
  528.     ULONG          abortreqsignal,
  529.                    sigmask,
  530.                    signals;
  531.  
  532.     abort = FALSE;
  533.  
  534.     struct EasyStruct AbortRebootES =
  535.     {
  536.       sizeof(struct EasyStruct),
  537.       0UL,
  538.       NAME,
  539.       SafeGetCatalogStr( ct, MSG_ABORTREBOOT_REQTEXT, MSG_ABORTREBOOT_REQTEXT_STR )
  540.       SafeGetCatalogStr( ct, MSG_ABORTREBOOT_REQGAD,  MSG_ABORTREBOOT_REQGAD_STR )
  541.     };
  542.  
  543.     if( (project . rebootdelay) < 1UL )
  544.     {
  545.       project . rebootdelay = 1UL;
  546.     }
  547.  
  548.     if( project . noreq )
  549.     {
  550.       abortreqwindow = NULL;
  551.     }
  552.     else
  553.     {
  554.       /* Here we must check if we got the "low mem" return value (see BuildEasyRequestArgs autodoc)
  555.        * which may be 0 or 1
  556.        * For 0, I cannot determinate if this is a result from alert or a 'real' low mem failure
  557.        */
  558.       abortreqwindow = BuildEasyRequestArgs( NULL, (&AbortRebootES), 0UL, NULL );
  559.  
  560.       if( (abortreqwindow == ((struct Window *)1UL)) || (abortreqwindow == NULL) )
  561.       {
  562.         main_retval2 = ERROR_NO_FREE_STORE;
  563.         main_retval  = RETURN_FAIL;
  564.  
  565.         return;
  566.       }
  567.     }
  568.  
  569.     abortreqsignal = ((abortreqwindow)?(1UL << abortreqwindow -> UserPort -> mp_SigBit):(0UL));
  570.  
  571.     sigmask = SIGBREAKF_CTRL_C | abortreqsignal;
  572.  
  573.     delay = (project . rebootdelay) * 2UL;
  574.  
  575.     /* for each cycle we'll check if any abort signal arrived (CTRL_C or requester) */
  576.     for( x = 0UL ; x <= delay ; x++ )
  577.     {
  578.       /* check if user aborts countdown */
  579.       signals = CheckSignal( sigmask );
  580.  
  581.       if( signals & SIGBREAKF_CTRL_C )
  582.       {
  583.         abort = TRUE;
  584.       }
  585.  
  586.       /* no window, no signal, no event processing ... */
  587.       if( abortreqsignal )
  588.       {
  589.         if( signals & abortreqsignal )
  590.         {
  591.           if( SysReqHandler( abortreqwindow, NULL, FALSE ) == 0L )
  592.           {
  593.             abort = TRUE;
  594.           }
  595.         }
  596.       }
  597.  
  598.       if( abort )
  599.       {
  600.         break;
  601.       }
  602.  
  603.       /* wait a little bit */
  604.       Delay( (TICKS_PER_SECOND / 2UL) );
  605.     }
  606.  
  607.     if( abort == FALSE )
  608.     {
  609.       if( abortreqwindow )
  610.       {
  611.         /* if we got no abort msg, check the requester for any outstanding msg */
  612.         if( SysReqHandler( abortreqwindow, NULL, FALSE ) == 0L )
  613.         {
  614.           abort = TRUE;
  615.         }
  616.       }
  617.     }
  618.  
  619.  
  620.     /* Check if user send us CTRL-C or has selected test mode using something like "Setenv Reboot OFF" */
  621.     if( abort || (project . off) )
  622.     {
  623.       main_retval2 = ERROR_BREAK;
  624.       main_retval  = RETURN_WARN;
  625.     }
  626.     else
  627.     {
  628.       /* bite in the dust */
  629.       ColdReboot();
  630.     }
  631.  
  632.     /* user has aborted the rebooting sequence */
  633.     FreeSysRequest( abortreqwindow );
  634. }
  635.  
  636.  
  637. STRPTR SafeGetCatalogStr( struct Catalog *ct, LONG id, STRPTR s )
  638. {
  639.     if( LocaleBase )
  640.     {
  641.       s = GetCatalogStr( ct, id, s );
  642.     }
  643.  
  644.     return( s );
  645. }
  646.  
  647.  
  648.  
  649.